home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / presto / prest_04.lha / src / threadq.h < prev    next >
C/C++ Source or Header  |  1989-06-06  |  3KB  |  197 lines
  1.  
  2. //
  3. // Thread Q stuff
  4. //
  5.  
  6.  
  7. //
  8. // ThreadQUnlocked should be used when the threadq is already 
  9. // associated with a locked data structuire (such as a synchronization
  10. // object).  We save having to test for locking.
  11. //
  12.  
  13. class ThreadQUnlocked    : public Oqueue    {
  14.     int    tq_neededstate;
  15. public:
  16.     ThreadQUnlocked(int neededstate, Thread *t = 0);
  17.     ~ThreadQUnlocked();
  18.     inline Thread* get();
  19.     inline Thread*     lookat();
  20.     inline void        append(Thread* t);
  21.     inline void    prepend(Thread* t);
  22.     inline void     remove(Thread* t);
  23.     virtual void print(ostream& = cout);
  24. };
  25.  
  26. class ThreadQ    : public Oqueue    {
  27.     int        tq_neededstate;        // sanity check
  28.     int        tq_length;
  29.     Spinlock     *tq_lock;
  30.     inline        void lock();
  31.     inline        void unlock();
  32. public:
  33.     ThreadQ(int neededstate, Thread *t = 0);
  34.     ~ThreadQ();
  35.     inline Thread*    get();
  36.     inline Thread*     lookat();
  37.     inline void        append(Thread* t);
  38.     inline void    prepend(Thread* t);
  39.     inline void     remove(Thread* t);
  40.     int        length()
  41.                 { return tq_length; }
  42.     virtual void print(ostream& = cout);
  43. };
  44.  
  45.  
  46.  
  47. inline
  48. Thread*
  49. ThreadQUnlocked::get()
  50. {  
  51.     Thread* t = (Thread*)(Oqueue::get());
  52.     if (t==0 || t->t_state&tq_neededstate) 
  53.         return t;
  54.     else
  55.            t->error("get bad state");
  56. }
  57.  
  58. inline
  59. Thread*
  60. ThreadQUnlocked::lookat()
  61. {
  62.     Thread* t = (Thread*)(Oqueue::lookat());
  63.     if (t==0 || t->t_state&tq_neededstate)
  64.            return t;
  65.     else
  66.            t->error("get bad state");
  67. }
  68.  
  69.  
  70. inline
  71. void
  72. ThreadQUnlocked::append(Thread* t)
  73. {
  74.     if (t==0 || t->t_state&tq_neededstate)    {
  75.         Oqueue::append(t); 
  76.     } else
  77.         t->error("Bad state append");
  78. }
  79.  
  80.  
  81.  
  82. inline
  83. void
  84. ThreadQUnlocked::prepend(Thread* t)
  85. {
  86.     if (t==0 || t->t_state&tq_neededstate)    {
  87.         Oqueue::prepend(t); 
  88.     }  else
  89.           t->error("Bad state prepend");
  90. }
  91.  
  92.  
  93. inline
  94. void
  95. ThreadQUnlocked::remove(Thread *t)
  96. { 
  97.     if (t==0 || t->t_state&tq_neededstate)    {
  98.         Oqueue::remove(t); 
  99.     } else
  100.           t->error("Bad state remoeve");
  101. }
  102.  
  103.  
  104. //
  105. // Locked threadq's
  106. //
  107. inline
  108. void ThreadQ::lock()
  109. {
  110.     register Spinlock *sp = tq_lock; 
  111.     sp->lock(); 
  112. }
  113.  
  114. inline
  115. void ThreadQ::unlock()
  116. {
  117.     register Spinlock *sp = tq_lock; 
  118.     sp->unlock(); 
  119. }
  120.  
  121.  
  122.  
  123. inline
  124. Thread*
  125. ThreadQ::get()
  126. {  
  127.     lock();
  128.     Thread* t = (Thread*)(Oqueue::get());
  129.     if (t)
  130.         tq_length--;
  131.     unlock();
  132.     
  133.     if (t==0 || t->t_state&tq_neededstate) 
  134.         return t;
  135.     else
  136.            t->error("get bad state");
  137. }
  138.             
  139. inline
  140. Thread*
  141. ThreadQ::lookat()
  142. {
  143.     Thread* t = (Thread*)(Oqueue::lookat());
  144.     if (t==0 || t->t_state&tq_neededstate)
  145.            return t;
  146.     else
  147.            t->error("get bad state");
  148. }
  149.     
  150.  
  151. inline
  152. void
  153. ThreadQ::append(Thread* t)
  154. {
  155.     if (t && t->t_state&tq_neededstate)    {
  156.         lock();
  157.         Oqueue::append(t); 
  158.         tq_length++;
  159.         unlock();
  160.     } else
  161.         t->error("Bad state append");
  162. }
  163.  
  164.  
  165.  
  166. inline
  167. void
  168. ThreadQ::prepend(Thread* t)
  169. {
  170.     if (t && t->t_state&tq_neededstate)    {
  171.         lock();
  172.         Oqueue::prepend(t);
  173.         tq_length++; 
  174.         unlock();
  175.     }  else
  176.           t->error("Bad state prepend");
  177. }
  178.  
  179. inline
  180. void
  181. ThreadQ::remove(Thread *t)
  182. { 
  183.     if (t && t->t_state&tq_neededstate)    {
  184.         lock();
  185.         Oqueue::remove(t); 
  186.         tq_length--;
  187.         unlock();
  188.     } else
  189.           t->error("Bad state remoeve");
  190. }
  191.  
  192.  
  193.  
  194.  
  195.  
  196.  
  197.